FUN
  The most popular computer language is BASIC, which I explained 
earlier. Now you'll learn a different computer language, called 
FORTRAN.
  Most maxicomputers and minicomputers understand both BASIC and 
FORTRAN. Some ideas are easier to express in BASIC; others are 
easier in FORTRAN.
  Most scientists and engineers on large computers use FORTRAN, 
not BASIC.
  IBM invented the first version of FORTRAN in 1957. Then came 
improvements, called FORTRAN II, FORTRAN III, and FORTRAN IV. The 
next version was called FORTRAN 77 because it was invented in 
1977. The newest version is called FORTRAN 90 because it was 
invented in 1990.
  Some computers use FORTRAN 77 or FORTRAN 90. Others still use 
FORTRAN IV or a slightly souped-up version of it (called FORTRAN 
IV-EXTENDED or FORTRAN V or WATFOR or WATFIV or FORTRAN 10).
  This chapter explains the popular FORTRAN features that work on 
practically all computers.

           Simple programs
  Here's a FORTRAN program:
      PRINT 10
10    FORMAT (1X,'CHIPMUNKS ARE CHUBBY')
      PRINT 20
20    FORMAT (1X,'GOLDFISH GIGGLE')
      PRINT 10
      END
  The top line says to print what's in line 10, so the computer 
will print CHIPMUNKS ARE CHUBBY. The next line says to print 
what's in line 20, so the computer will print GOLDFISH GIGGLE. 
The next line says to print what's in line 10, so the computer 
will print CHIPMUNKS ARE CHUBBY again.Altogether, the program 
makes the computer print:
CHIPMUNKS ARE CHUBBY
GOLDFISH GIGGLE
CHIPMUNKS ARE CHUBBY
  Notice:
Each program line is indented 6 spaces, so it begins in the 7th 
position.
Each FORMAT begins with 1X.
Each string is enclosed in apostrophes.
  You must number every line that's referred to. For example, you 
must number the FORMAT lines, since the PRINT lines refer to 
them. You don't have to number the PRINT lines.
  The bottom line of every FORTRAN program must be END.
  Different versions On PDP computers, say TYPE instead of PRINT. 
On CDC computers using TS FORTRAN, replace each apostrophe by an 
asterisk. On IBM computers, put STOP above END, so the bottom two 
lines of your program are:
      STOP
      END

                                         How to type the program 
Ask the people in your computer center how to feed a FORTRAN 
program into the computer. On some computers, you must put an 
edit number in front of each line:
00100         PRINT 10
00110   10    FORMAT (1X,'CHIPMUNKS ARE CHUBBY')
00120         PRINT 20
00130   20    FORMAT (1X,'GOLDFISH GIGGLE')
00140         PRINT 10
00150         END
                                         Some computers don't 
require you to indent each line. To indent quickly on PDP 
computers, hold down the CONTROL key, while you type the letter 
I.
                                         Be brief Each line of 
your program must be brief: no more than 72 characters, including 
the spaces at the beginning of the line.

                                                 Carriage controls
                                         The 1X at the beginning 
of each FORMAT is called the carriage control. It means: print 
the format normally.
                                         For weirder printing, 
replace the 1X by '0' or '1' or '+':
      PRINT 10
10    FORMAT (1X,'NIFTY')
      PRINT 20
20    FORMAT ('0','SAL')
      END
                                         In line 10, the 1X makes 
the computer print NIFTY normally. In line 20, the 
zero-in-apostrophes make the computer leave a blank line, then 
print SAL.
                                         The computer will print:
NIFTY

SAL
                                         Suppose you change the 
carriage control to '1':
      PRINT 10
10    FORMAT (1X,'NIFTY')
      PRINT 20
20    FORMAT ('1','SAL')
      END
If your terminal uses paper, the '1' makes the computer print SAL 
on a new page. If your terminal uses a screen instead of paper, 
the '1' makes the computer erase the screen before printing SAL.
                                         Suppose you change the 
carriage control to '+':
      PRINT 10
10    FORMAT (1X,'NIFTY')
      PRINT 20
20    FORMAT ('+','SAL')
      END
If your terminal uses paper, the '+' makes the computer print SAL 
in the same place as NIFTY, like this:
NIFTYSAL
If your terminal uses a screen instead, the computer will print 
NIFTY, but then the NIF will suddenly disappear, and you'll see 
SALTY.
  To print the symbol 0-, print 0 in the same place as -. To 
print the symbol =/, print = in the same place as /. To print 
0=-/A, print 0=A in the same place as -/. If your terminal uses 
paper, the program prints 0=-/A:
      PRINT 10
10    FORMAT (1X,'0=A')
      PRINT 20
20    FORMAT ('+','-/')
      END
  Different versions If you're using a Hazeltine terminal or CDC 
TS FORTRAN, the carriage controls won't work.

      Fancy formats
  In the format line, you can play fancy tricks.
  Multiple fields Examine this program:
      PRINT 10
10    FORMAT (1X,'JOHN','NY')
      END
The FORMAT consists of three fields: the first is the carriage 
control 1X, the second is `JOHN', and the third is `NY'. The 
computer will print JOHN and NY on the same line:
JOHNNY
  Another example:
      PRINT
10    FORMAT (1X,'EAT A',8X,'MEATBALL')
      END
The computer will print EAT A, then 8 blank spaces, then 
MEATBALL:
EAT A        MEATBALL
  This program does the same thing:
      PRINT 10
10    FORMAT (1X,'EAT A',T15,'MEATBALL')
      END
It makes the computer print EAT A, then Tab over to the 15th 
position on the line, and print MEATBALL. When the computer tabs 
to the 15th position, it considers the carriage control to be the 
first ``position''; the E in EAT is the first character the 
computer will print, and the computer considers it to be the 
second ``position''; the A in EAT is the second character the 
computer will print, and the computer considers it to be the 
third ``position''; the M in MEATBALL is the 14th character the 
computer will print, since the T15 says it is the 15th 
``position''.
  Here's another program for meatball lovers:
      PRINT 10
10    FORMAT (1X,'EAT A',1X,'MEATBALL')
The computer will print EAT A, then 1 blank space, then MEATBALL:
EAT A MEATBALL
If you say X instead of 1X, the computer will gripe.
                             Multiple records This program quotes 
Julius Caesar:
      PRINT 10
10    FORMAT (1X,'I CAME')
      PRINT 20
20    FORMAT (1X,'I SAW')
      PRINT 30
30    FORMAT (1X,'I CONQUERED')
      END
The computer will print:
I CAME
I SAW
I CONQUERED
                             This program does the same thing:
      PRINT 10
10    FORMAT (1X,'I CAME'/1X,'I SAW'/1X,'I CONQUERED')
      END
Line 10 consists of 3 records: the first is 1X,`I CAME'; the 
second is 1X,`I SAW'; the third is 1X,`I CONQUERED'. Each record 
begins with a carriage control; the records are separated by 
slashes. The computer will print each record on a separate line.
                             Example:
      PRINT 10
10    FORMAT (1X,'PLEASE'/1X,'NIBBLE'//1X,'MY'/////1X,'CHEESE')
      END
Line 10 makes the computer print several lines. The first line 
will say PLEASE. The next line will say NIBBLE. The next line 
will be blank. The next line will say MY. The next 4 lines will 
be blank. The last line will say CHEESE. So altogether, the 
computer will print:
PLEASE
NIBBLE

MY




CHEESE
                             Repeated formats The computer can 
feel very depressed:
      PRINT 10
10    FORMAT (1X,'I FEEL ',3('DOWN'))
      END
Line 10 is an abbreviation for this format:
              1X,'I FEEL ','DOWN','DOWN','DOWN'
The computer will print:
I FEEL DOWNDOWNDOWN
                             Let's burp and pray:
      PRINT 10
10    FORMAT (1X,'JACK ',2('BURPS'/1X,'MARY '),'ALSO PRAYS')
      END
Line 10 is an abbreviation for this format:
              1X,'JACK ','BURPS'/1X,'MARY ','BURPS'/1X,'MARY 
','ALSO PRAYS'
The computer will print:
JACK BURPS
MARY BURPS
MARY ALSO PRAYS
                             Double apostrophe To make the 
computer print an apostrophe, use two apostrophes next to each 
other.
      PRINT 10
10    FORMAT (1X,'MOMMY ISN''T HERE')
      END
The computer will print:
MOMMY ISN'T HERE

                  Continuation
  Some computers look at only the first 72 characters of each 
line of your program: if your line contains more than 72 
characters, it won't work.
  If you want to type a long statement, type just the first 72 
characters. On the line below, type the remaining characters, 
beginning in the 7th print position; and in the 6th print 
position type a 6:
      PRINT 10 
10    FORMAT (1X,'I LIKE ROSES IN MY TEA.'/1X,'THEY MAKE IT GLOW 
RED, LI
     6KE HOT BLOOD.')
      END
The computer will print:
I LIKE ROSES IN MY TEA.
THEY MAKE IT GLOW RED, LIKE HOT BLOOD.
A line that has a 6 in column 6 is called a continuation line, 
because it's a continuation of the line above it.
  (I suggest you put a 6 in column 6, or a * in column 6, or a $ 
in column 6. In fact, you can put any character in column 6, 
except a zero. Choose your favorite character; the computer 
doesn't care.)
  Different versions On PDP computers, put the 6 immediately 
after a controlled I, instead of in column 6:
10      FORMAT (1X,'I LIKE ROSES IN MY TEA.'/1X,'THEY MAKE IT 
GLOW RED, LI
        6KE HOT BLOOD.')
(I suggest you put a 6 after the controlled I. But you can put in 
any non-zero digit, instead of a 6.)
  On CDC computers using TS FORTRAN, type a + instead of a 6, and 
put it immediately after the edit number, with no intervening 
spaces:
00120 10 FORMAT (1X,'I LIKE ROSES IN MY TEA.'/1X,'THEY MAKE IT 
GLOW RED, LI
00130+KE HOT BLOOD.')

                      GO TO
  You can say GO TO:
10    PRINT 20
20    FORMAT (1X,'CAT')
      PRINT 30
30    FORMAT (1X,'DOG')
      GO TO 10
      END
The top line says to print what's in line 20, so the computer 
will print:
CAT
The next line says to print what's in line 30, so the computer 
will print:
DOG
The next line makes the computer go back to line 10. The computer 
will print CAT again, then DOG again, then jump back to line 10 
again. . . . The computer will try to print the words CAT and DOG 
again and again, forever.

                      STOP
  The computer understands the word STOP:
      PRINT 10
10    FORMAT (1X,'BUBBLE GUM')
      PRINT 20
20    FORMAT (1X,'SHAKESPEARE')
      STOP
      PRINT 30
30    FORMAT (1X,'DADA')
      END
The top line says to print what's in line 10, so the computer 
will print BUBBLE GUM. The next line says to print what's in line 
20, so the computer will print SHAKESPEARE. The next line says 
STOP, so the computer will stop. It will never print DADA.


                      MATH
  FORTRAN handles math rather well.

          Integers versus real numbers
  FORTRAN distinguishes between integers and real numbers. Here's 
how FORTRAN defines them. . . . 
  An integer contains no decimal point and no exponent.
IntegerNot an integerComment
-27   -27.0     An integer contains no decimal point.
50000 5E4       An integer contains no exponents.
A real number contains either a decimal point or the letter E.
Real numberNot a real number
-27.0     -27
2.35E8    235000000
5E4       50000
  The largest permissible integer is different from the largest 
permissible real:
Computer          Largest integerLargest realTiniest real
PDP-11 using FORTRAN IV          327671.7E382.9E-39
PDP-11 using FORTRAN IV-PLUS     21474836471.7E382.9E-39
PDP-10 or Honeywell    343597383671.7E382.9E-39
IBM mainframe          21474836477.2E75 5.4E-79
CDC               2814749767106552.5E3223.1E-294
  Integers are also called fixed-point numbers. Real numbers are 
called floating-point numbers.

                    Variables
  In BASIC, X can stand for a number, such as 3.7. The same is 
true in FORTRAN. A variable can be a letter (such as X) or a 
letter-followed-by-a-combination-of-letters-and-digits (such as 
FUN4U2).
  The variable must be short: no more than 6 characters. AVERAGE 
is too long: say AVERAG instead.
  If the variable begins with I, J, K, L, M, or N, it stands for 
an integer. If it begins with some other letter, it stands for a 
real number.

             Using integer variables
  Here's a simple example:
      JUNKY=-47
      PRINT 10, JUNKY
10    FORMAT (1X,I3)
      END
  Since JUNKY begins with J, it stands for an integer. The first 
line says JUNKY stands for the integer -47. The second line says 
to print JUNKY, using line 10. Line 10 explains how to print 
JUNKY. The I3 means: print it as an Integer having 3 characters. 
The computer will print:
-47
  If you change the I3 to I4, the computer will print JUNKY as an 
Integer having 4 characters. To print a total of 4 characters, 
the computer will print a blank space in front of -47, like this:
 -47
  If you change to I5, the computer will print JUNKY as an 
Integer having 5 characters, by printing two blank spaces in 
front of -47:
  -47
  If you change to I2, the computer will try to print JUNKY as an 
integer having 2 characters. But it's impossible to express -47 
by using only 2 characters. The computer will obey the format and 
print 2 characters, but will make them asterisks:
**

                                                     Another 
example:
      NUM=31.9
      PRINT 10, NUM
10    FORMAT (1X,I4)
      END
Since NUM begins with N, it stands for an integer. The program's 
top line tries to make NUM stand for 31.9; but that's impossible, 
since 31.9 isn't an integer. The computer will omit the .9 and 
make NUM stand for the integer 31. The computer will print 31, 
using an I4 format:
  31
                                                     Example:
      JOE=-5.8
      PRINT 10, JOE
10    FORMAT (1X,I4)
      END
The computer will set JOE equal to the integer -5 and print it:
  -5

  Example:
      JAIL=74
      KRIMNL=829
      PRINT 10, JAIL,KRIMNL
10    FORMAT (1X,I2,I3)
      END
Since JAIL begins with J, and KRIMNL begins with K, they're both 
integers. The computer will print JAIL and KRIMNL, using the 
format in line 10. The format says to print a 2-character 
integer, then a 3-character integer. The computer will print:
74829
If you change the format to (1X,I2,4X,I3), the computer will 
print a 2-character integer, then 4 blanks, then a 3-character 
integer:
74    829
If you change the format to ___ 
10    FORMAT (1X,'JAIL NUMBER',1X,I2,1X,'CONTAINS 
CRIMINAL',1X,I3)
the computer will print JAIL NUMBER, then a blank, then a 
2-character integer, then a blank, then CONTAINS CRIMINAL, then a 
blank, then a 3-character integer:
JAIL NUMBER 74 CONTAINS CRIMINAL 829
  Example:
      J=43
      K=75
      L=96
      M=81
      N=24
      PRINT 10, J,K,L,M,N
10    FORMAT (1X,I2,I2,I2,I2,I2)
      END
The computer will print 43, then 75, then 96, then 81, then 24:
4375968124
You can write that format more briefly:
10    FORMAT (1X,5I2)
If you change the format to (1X,5I3), the computer will print 
each integer as 3 characters ___ a blank followed by two digits:
 43 75 96 81 24
If you change the format to (1X,I3), the computer will print only 
one integer per line:
 43
 75
 96
 81
 24
If you change the format to (1X,2I3), the computer will print 2 
integers per line:
 43 75
 96 81
 24
If you change the format to (1X,'GOSH',I3,1X,'SUPERB',I3,1X,'JEEP
ERS'), the computer will print 2 integers per line:
GOSH 43 SUPERB 75 JEEPERS
GOSH 96 SUPERB 81 JEEPERS
GOSH 24 SUPERB
  To be safe, use I14 format for integers. On most computers, I14 
handles even the largest integers, and prints blank spaces 
between them.

              Using real variables
  The I format is only for integers. For real numbers, use F or G 
format instead.
  F format The F format is easy to understand:
      RADIUS=-586.39
      PRINT 10, RADIUS
10    FORMAT (1X,F7.2)
      END
Since RADIUS doesn't begin with I, J, K, L, M, or N, it stands 
for a real number. The first line says RADIUS stands for the real 
number -586.39. The second line says to print RADIUS, using the 
format in line 10. The F7.2 means: print it as a floating-point 
number having 7 characters, 2 of them after the decimal point. 
The computer will print:
-586.39
  If you change the F7.2 to a different format, the following 
chart shows what happens; in the chart, each þ represents a blank 
space:
FormatWhat the computer printsComment
F8.2  þ-586.39          To print 8 characters instead of 7,
                        it prints a blank space at the beginning.

F8.3  -586.390          To print 3 characters after the decimal 
point
                        instead of 2, it prints a zero at the 
end.

F8.1  þþ-586.4          To print 1 character after the decimal 
point
                        instead of 2, it rounds the .39 to 4.

F8.4  ********          To print 4 characters after the decimal 
point,
                        the computer would have to print 
-586.3900.
                        Since that requires more than 8 
characters,
                        the computer complains by printing 
asterisks.
  G format To print a real number, the safest format is G14.6, 
because G14.6 can handle any real number well, even if the number 
is very large or very tiny.
  G14.6 prints 14 characters altogether, 6 of which are 
significant digits. Here are examples of numbers printed in G14.6 
format:
þ-0.283941E-29
þþ0.293027þþþþ
þþþ5.34523þþþþ
þþþ39.4539þþþþ
þþþ47802.3þþþþ
þþþ986327.þþþþ
þþ0.288341E+24
  Example:
      PRUNES=17
      PRINT 10, PRUNES
10    FORMAT (1X,G14.6)
      END
Since PRUNES doesn't begin with I, J, K, L, M, or N, it stands 
for a real number. When the computer encounters the first line of 
the program, it will set PRUNES equal to the real number 17.0. It 
will print:
   17.0000
The program will run faster if you change the top line to this:
      PRUNES=17.0
  E format For real numbers, the usual formats are F and G, but 
another option is E.
  If you say E14.6 instead of G14.6, the computer will print an E 
in the answer. Here are examples:
Using G14.6 formatUsing E14.6 format
þ-0.283941E-29þ-0.283941E-29
þþ0.293027þþþþþþ0.293027E+00
þþþ5.34523þþþþþþ0.534523E+01
þþþ39.4539þþþþþþ0.394539E+02
þþþ47802.3þþþþþþ0.478023E+05
þþþ986327.þþþþþþ0.986327E+06
þþ0.288341E+24þþ0.288341E+24
  The G14.6 format is easier for a human to read than E14.6. But 
most programmers are stupid, don't know about G14.6, and use 
E14.6 instead.
                                                     P format 
FORTRAN's notation differs from BASIC.
                                                     If you ask 
the computer to print 288341000000000000000000.0 in FORTRAN by 
using G14.6 (or E14.6), the computer will normally print a 0 
before the decimal point, like this: 0.288341E+24. In BASIC, the 
computer will print a non-zero digit before the decimal point, 
like this: 2.88341E+23.
                                                     If you're 
writing a program in FORTRAN, but you prefer BASIC's notation, 
ask for 1PG14.6 (or 1PE14.6). The 1P makes the computer imitate 
BASIC. But if a FORMAT contains 1PG, it must not contain F 
afterwards; this will print a wrong answer:
      FORMAT (1X,1PG14.6,F8.2)
                        
                   Here is P.   The F afterwards
                                   prints a wrong answer!

                                                          Operations
                                                     For 
addition, subtraction, multiplication, and division, FORTRAN uses 
the same symbols as BASIC.
      N=2*(3+1)
      S=7.3+2.1
      PRINT 10, N,S
10    FORMAT (1X,I14,G14.6)
      END
Since N is 8, and S is 9.4, the computer will print:
             8   9.40000
                                                     Exponents 
For exponents, FORTRAN uses a double star:
      J=7**2
      P=.5**3
      PRINT 10, J,P
10    FORMAT (1X,I14,G14.6)
      END
Since J is 72 (which is 49), and P is .53 (which is .125), the 
computer will print:
            49   0.125000
                                                     For negative 
exponents, you need parentheses. You must say 6.1**(-2), not 
6.1**-2.
                                                     What type of 
answer? When you combine integers, the answer's an integer:
2+3 is 5
8-8 is 0
2*4 is 8
399/100  is 3 (not 3.99)
11/4     is 2 (not 2.75)
3/4      is 0 (not 0.75)
10**(-2) is 0 (not 0.01)
                                                     When you 
combine real numbers, the answer is real:
4.1+2.9      is 7.0 (not 7)
8.0-8.0      is 0.0 (not 0)
399.0/100.0  is 3.99
11.0/4.0     is 2.75
3.0/4.0      is .75
10.0**(-2.0) is .01

  When you combine an integer with a real number, the answer is 
real:
3+2.0      is 5.0
399/100.0  is 3.99
11/4.0     is 2.75
3/4.0      is .75
10.0**(-2) is .01
  Compare these:
7/10*10    is 0(because 7/10 is 0)
7/10*10.0  is 0.0(because 0*10.0 is 0.0)
7/10.0*10  is 7.0(because 7/10.0 is .7)
  Example:
      JERK=20.0+30.9
      PRINT 10, JERK
10    FORMAT (1X,I14)
      END
Since JERK begins with J, it stands for an integer. Since 
20.9+30.9 is 51.8, JERK stands for the integer 51. The computer 
will print:
            51
  Another example:
      APPLE=37/10
      PRINT 10, APPLE
10    FORMAT (1X,G14.6)
      END
Since APPLE begins with A, it stands for a real number. Since 
37/10 is 3, APPLE stands for the real number 3.0. The computer 
will print:
   3.00000
  Crimes that slow down the computer cop If you commit one of 
these crimes, the computer will work slowly. . . . 
little crime: use a real number
medium crime: mix reals with integers
big crime: use a real exponent
  For example, the computer handles 2.0+2.0 slower than 2+2, 
because 2.0+2.0 is a little crime.
  The bigger the crime, the slower the computer works. For 
example, the computer handles 2.1+7 (which is a medium crime) 
slower than 2.1+7.0 (which is just a little crime). Likewise, X=0 
(a medium crime) gets handled slower than X=0.0 (a little crime).
  5.1**2.0 is a big crime, since its exponent (2.0) is real. The 
computer handles it slower than 5.1**2, which is just a medium 
crime.
  5**3.1 is a gigantic crime, since it's a medium crime and a big 
crime simultaneously. Because the crime's so gigantic, some 
computers refuse to handle it. Say 5.0**3.1 instead.
                                        Advice about variables
                             FORTRAN, like BASIC, distinguishes 
variables, constants, and expressions:
X                                is a variable
2.7                              is not a variable; it's a 
numeric constant
`LOVE'                           is not a variable; it's a string 
constant
X+Y                              is not a variable; it's an 
expression
                             In a PRINT statement, some computers 
allow only variables. . . . 
                             allowed: PRINT 10, X
not                          allowed: PRINT 10, 2.7instead, say 
X=2.7 and PRINT 10, X
not                          allowed: PRINT 10, `LOVE'instead, 
say PRINT 10 and 10 FORMAT (1X,`LOVE')
not                          allowed: PRINT 10, X+Yinstead, say 
Z=X+Y and PRINT 10, Z
Other computers are more generous and allow anything. Find out 
about yours.
                             To help other humans understand your 
program, use long variable names throughout your program. Say 
RADIUS, not R; say AREA, not A; say VOLUME, not V; say SUM, not 
S; say TOTAL, not T. Because FORTRAN's variables are restricted 
to six characters, you might have to omit the last few syllables 
(revolutions becomes REVOLU) or the last few vowels (RVLTNS).
                             If you want a variable to be real, 
but its English name begins with I, J, K, L, M, or N, begin its 
FORTRAN name with an A (mass becomes AMAS; length becomes ALENGT 
or ALNGTH). If you want a variable to be an integer, but its 
English name doesn't begin with I, J, K, L, M, or N, begin its 
FORTRAN name with an I (population becomes IPOPUL) or misspell it 
(count becomes KOUNT) or choose a synonym (instead of position, 
say location, which is LOCATN).

            PLEASANT I/O
  You learned how to make the computer PRINT by using a FORMAT. 
Now you'll learn about PRINT's opposite (READ) and how to omit 
FORMATs altogether.

                READ
  The computer can READ.
      PRINT 10
10    FORMAT (1X,'TYPE SOME DIGITS')
      READ 20, N
20    FORMAT (I4)
      PRINT 30, N
30    FORMAT (1X,I4)
      END
  When you run the program, here's what happens. . . . 
  The top two lines make the computer print:
TYPE SOME DIGITS
  The word READ makes the computer wait for you to type 
something; it's like the BASIC word INPUT. The computer will wait 
for you to type the value of N, but line 20's FORMAT makes the 
computer read just the first 4 characters. For example, if you 
type ___ 
-75198622
the computer will read just the first 4 characters, which are 
-751; it will ignore the 98622; so N will be -751. Line 30's 
FORMAT makes the computer print:
-751
Altogether, the run looks like this:
The computer says:TYPE SOME DIGITS
You say:    -75198622
The computer replies:-751
  Hassles Line 30's FORMAT contains a carriage control 1X, but 
line 20's FORMAT omits the carriage control. Put a carriage 
control in formats that PRINT, but not in formats that READ.
  On PDP computers, say ACCEPT instead of READ.
  Blank spaces If you input a blank space, the computer treats it 
as a zero.
  For example, suppose you input:
-3 28219
Because of the I4 format, the computer will read just the first 4 
characters, which are -3 2; the blank space between the 3 and the 
2 is treated as a zero, so N will be -302.
  Suppose you input:
57
Because of the I4 format, the computer will read the 5, the 7, 
and two blanks. Since the blanks are treated as zeros, N will be 
5700.
  Suppose you input:
þþþ9527
Because of the I4 format, the computer will read the three 
beginning blanks and the 9. Since the blanks are treated as 
zeros, N will be 0009, which is 9. Line 30 makes the computer 
print:
   9

                                         Multiple 
variablesSuppose you write a program containing these lines:
      READ 20, L,M,N
20    FORMAT (I3,I4,2X,I2)
When you run that program, suppose you input:
58194138972824
The I3 format makes the first 3 characters (581) be L. The I4 
format makes the next 4 characters (9413) be M. The 2X format 
makes the next 2 characters (89) be skipped over. The I2 format 
makes the next two characters (72) be N. The remaining characters 
(824) are ignored. So the line is split like this. . . . 
Line you input:                                          
58194138972824
Fields in the FORMAT statement:                              I4 
2XI2
Variables in the READ statement:                          L        
                                                         ³  ³   ³ 
³ ³
                                                         ³I3³   ³ 
³ ³
                                                         ³  ³ M ³ 
³N³
                                         Suppose you write a 
program containing these lines:
      READ 20, J,K,L,M,N
20    FORMAT (2I3)
The format says to read two 3-character integers on each line. 
Suppose you input:
78345692
85431684
46185327
J will be 783, and K will be 456. L will be 854, and M will be 
316. N will be 461.
                                         Real variables Here's 
how to input a real number:
      PRINT 10
10    FORMAT (1X,'TYPE SOME DIGITS')
      READ 20, P
20    FORMAT (F6.2)
      PRINT 30, P
30    FORMAT (1X,G14.6)
      END
                                         The F6.2 format means: 
read 6 characters; if they don't contain the decimal point, 
insert it before the last 2 digits.
                                         For example, suppose you 
input:
327514968
The computer reads the first 6 characters (327514). Since they 
don't contain the decimal point, the computer inserts it before 
the last 2 digits, so P is 3275.14. Line 30 prints:
   3275.14
                                         Suppose you input:
7.5423967
The computer reads the first 6 characters (7.5423). Since they 
already contain the decimal point, P is 7.5423. Line 30 says to 
print that number by using 6 significant digits, so the computer 
prints:
   7.54230
                                         Suppose you input:
497E3
The computer reads 6 characters (497E3, followed by a blank). 
Since blanks are treated as zeros, the computer gets 497E30. 
Since 497E30 doesn't contain the decimal point, the computer 
inserts it before the last 2 digits, so P is 4.97E30. Line 30 
prints:
  0.497000E+31

          Omitting formats
  Most computers let you omit numeric formats. This program works 
on most modern computers (such as computers having FORTRAN 77, 
PDP-20 computers, PDP-10 computers using FORTRAN 10, PDP-11 
computers using FORTRAN IV-PLUS, CDC computers using FORTRAN 
IV-EXTENDED, and IBM computers using FORTRAN H-EXTENDED):
      PRINT 10          On PDP computers,
10    FORMAT (1X,'TYPE TWO INTEGERS')say TYPE instead of
      READ *, M,N       PRINT, and ACCEPT
      ISUM=M+N          instead of READ.
      PRINT *, ISUM
      END
  The word READ is followed by an asterisk, instead of a FORMAT 
number. The last PRINT is followed by an asterisk also. The 
asterisk makes the computer invent its own FORMAT. To make the 
program add 241 and 82976, input the numbers, separated by a 
comma:
241,82976
The computer will notice the comma's location and automatically 
use an I3 format for 241, a 1X format to skip over the comma, and 
an I5 format for 82976. To print ISUM, the computer will use a 
safe format, such as I14 or I15.
  By omitting formats, you gain two advantages:
  1. You can write FORTRAN programs more quickly.
  2. The person who inputs doesn't have to worry about whether 
his spacing matches the format. The computer invents a format 
that matches his input.
  Different versions On CDC computers using TS FORTRAN and on 
Honeywell computers, omit the asterisk after READ and PRINT:
      PRINT 10
10    FORMAT (1X,'TYPE THE NUMBERS')
      READ, M,N
      ISUM=M+N
      PRINT, ISUM
      END
  On PDP-10 computers using F40 FORTRAN, and on PDP-11 computers 
using regular FORTRAN IV, you need FORMATs, but omit the number 
in the I format:
      TYPE 10
10    FORMAT (1X,'TYPE THE NUMBERS')
      ACCEPT 20, M,N
20    FORMAT (1X,2I)
      ISUM=M+N
      TYPE 30, ISUM
30    FORMAT (1X,I)
      END
  Real numbers You can use similar short cuts for real numbers.


                      LOGIC
  You learned how to say GO TO and STOP. Taking those concepts 
further, let's see how to say IF and DO and give a computed GO 
TO.

                       IF
  FORTRAN uses these clauses:
Clause    Meaning
IF (I .LT. 5)If I is Less Than 5
IF (I .GT. 5)If I is Greater Than 5
IF (I .LE. 5)If I is Less than or Equal to 5
IF (I .GE. 5)If I is Greater than or Equal to 5
IF (I .EQ. 5)If I is EQual to 5
IF (I .NE. 5)If I is Not Equal to 5
  Notice that each relational operator (such as LT) must be 
enclosed in periods, and each condition (such as I .LT. 5) must 
be enclosed in parentheses.
  By using those clauses, you can build statements:
Statement       Meaning
IF (I .LT. 5) J=3If I is Less Than 5, let J=3
IF (I .LT. 5) GO TO 80If I is Less Than 5, go to line 80.
IF (I .LT. 5) STOPIf I is Less Than 5, stop.
IF (I .LT. 5) PRINT 10, JIf I is Less Than 5, print J using line 
10's FORMAT.
  You can use the words AND and OR:
Idea            How to say it in FORTRAN
If I is 2 or 9 or 13IF (I .EQ. 2 .OR. I .EQ. 9 .OR. I .EQ. 13)
If I is an integer from 1 to 8IF (I .GE. 1 .AND. I .LE. 8)
If X<Y<Z        IF (X .LT. Y .AND. Y .LT. Z)
If A is less than both B and CIF (A .LT. B .AND. A .LT. C)
If X negative or between 5 & 9IF (X .LT. 0.0 .OR. X .GE. 5.0. 
.AND. X .LE. 9.0)
  Take this test: cover the column that says ``How to say it in 
FORTRAN''. Try to translate each ``Idea'' into FORTRAN, then 
check your answers. If one of your answers is shorter than the 
correct answer, take the test again! For example, the following 
answer to the first idea is wrong:
IF (I .EQ. 2 .OR. 9 .OR. 13)
  END IF FORTRAN 77 lets you say ``END IF''.
  For example, here's how FORTRAN 77 lets you say, ``If I is 
greater than 5, let J be 80 and let K be 90'':
      IF (I .GT. 5) THEN
         J=80
         K=90
      END IF
  Here's how FORTRAN 77 lets you say, ``If I is greater than 5, 
let J be 80 and let K be 90; but if I is not greater than 5, let 
J be 30 and let K be 50'':
      IF (I .GT. 5) THEN
         J=80
         K=90
      ELSE
         J=30
         K=50
      END IF
  Here's how FORTRAN 77 lets you say, ``If I is greater than 5, 
let J be 80 and let K be 90; if I is not greater than 5, but I is 
greater than 2, let J be 81 and let K be 92; if I is not greater 
than 2, let J be 30 and let K be 50'':
      IF (I .GT. 5) THEN
         J=80
         K=90
      ELSE IF (I .GT. 2) THEN
         J=81
         K=92
      ELSE
         J=30
         K=50
      END IF
  Warning: to say ``END IF'', you must get FORTRAN 77. If you use 
FORTRAN IV instead, ``END IF'' doesn't work. I recommend that you 
get FORTRAN 77.
                                                     Three-way IF 
Here's a different kind of IF statement:
      IF (X) 20,50,90
It means:
If X is a negative number, go to line 20.
If X is zero, go to line 50.
If X is a positive number, go to line 90.
                                                     That kind of 
IF statement is called a three-way IF, or an arithmetic IF. (To 
pronounce ``arithmetic'', put the accent on met.) The other kind 
of IF is called a logical IF.
           Computed GO TO
  In your program, you can say:
      GO TO (80,100,20,350), I
That means: go to either 80, 100, 20, or 350, depending on what I 
is. More specifically, it means:
Go to line  80, if I is 1.
Go to line 100, if I is 2.
Go to line  20, if I is 3.
Go to line 350, if I is 4.
Proceed to the line underneath, if I is a different integer.
  That FORTRAN statement is called a computed GO TO. It resembles 
this BASIC statement:
30 ON I GO TO 80,100,20,350

                 DO
  This program prints the square of every number from 80 to 100, 
and then prints GET LOST:
BASIC         FORTRAN
10 FOR I = 80 TO 100      DO 30 I=80,100
20     PRINT I^2         J=I**2
                       PRINT 20, J
              20       FORMAT (1X,I14)
30 NEXT I     30    CONTINUE
40 PRINT "GET LOST"      PRINT 40
              40    FORMAT (1X,'GET LOST')
                    END
  If you compare the BASIC with the FORTRAN, you'll notice 
FORTRAN uses the word DO instead of FOR, uses a comma instead of 
TO, and uses CONTINUE instead of NEXT. The statement DO 30 I=5,9 
means: DO every line up through line 30, repeatedly, as I goes 
from 5 to 9. In BASIC, programmers indent every line between FOR 
and NEXT; in FORTRAN, programmers indent every line between DO 
and CONTINUE. In BASIC, the indented lines are called a 
FOR...NEXT loop; in FORTRAN, they're called a DO loop.
  If you want the computer to print the square of every fifth 
number from 80 to 100, change the program's top line:
BASIC             FORTRAN
10 FOR I = 80 TO 100 STEP 5DO 30 I=80,100,5

                                         Restrictions In a DO 
statement, some computers allow only positive integer variables 
and constants:
Not allowed                                        Why         
Say this instead
DO 10 X=1.0,5.0                                    reals are not 
allowed                                                        DO 
10 I=1,5

DO 10 X=17.3,98.5                                  reals are not 
allowed                                                        DO 
10 I=173,985
                                                                  
X=I/10.0

DO 10 I=0,5                                        0 is not 
positive                                                       DO 
10 J=1,6
                                                                  
I=J-1

DO 10 I=-3,5                                       -3 is not 
positive                                                       DO 
10 J=1,9
                                                                  
I=J-4

DO 10 I=100,7,-1                                   -1 is not 
positive                                                       DO 
10 J=7,100
                                                                  
I=107-J

DO 10 I=5,J+K                                      + is not 
allowed                                                        
L=J+K
                                                               DO 
10 I=5,L
                                         Other computers are more 
generous and allow anything. Find out about yours.
                                         In the middle of a DO 
loop, don't change the value of the index. For example, if your 
DO loop begins with ___ 
      DO 10 I=1,100
don't insert this line in the middle of your loop:
         I=14
It will confuse the computer.
                                         Zero-trip DO loops If 
you say ___ 
      DO 10 I=1,N
the computer will do up through line 10, N times. For example, if 
N is 73, the computer will do up through line 10, 73 times. If N 
is 2, the computer will do up through line 10, twice. If N is 1, 
the computer will do up through line 10, once.
                                         What happens if N is 
less than 1? The answer depends on which version of FORTRAN 
you're using.
                                         If you're using FORTRAN 
77, the computer will skip the loop, and proceed to the line 
below line 10. But if you're using FORTRAN IV, the computer will 
do the loop once, as if N were 1.
                                         FORTRAN 77 makes more 
sense; but alas, many computers still use FORTRAN IV.
                                         A DO loop that FORTRAN 
77 skips (because N is less than 1) is called a zero-trip DO 
loop, because the computer takes ``zero trips through the loop'' 
(instead of 1 trip or 2 trips or many trips).
                                         Find out whether your 
computer's version of FORTRAN resembles FORTRAN 77 and permits 
zero-trip DO loops.

                      LISTS
  To handle lists, use these tricks. . . . 

                   Subscripts
  Like BASIC, FORTRAN permits subscripts:
      DIMENSION X(4)
      X(1)=.21
      X(2)=.3
      X(3)=1.08
      X(4)=5.0
      SUM=X(1)+X(2)+X(3)+X(4)
      PRINT 10, X,SUM
10    FORMAT (1X,G14.6)
      END
  The top line says X will be a list of 4 numbers, called X(1), 
X(2), X(3), and X(4). Since X doesn't begin with I, J, K, L, M, 
or N, the 4 numbers will be real.
  The PRINT statement makes the computer print the list and the 
SUM, like this:
  0.210000
  0.300000
   1.08000
   5.00000
   6.59000
  If you change the format to (1X,5G14.6), the computer will 
print all 5 numbers on the same line:
  0.210000      0.300000       1.08000       5.00000       
6.59000
  You must say DIMENSION if your program uses subscripts, even if 
the subscripts are small. Say DIMENSION at the very top of the 
program. Make sure you say DIMENSION, not DIM or DIMENSIONS. The 
computer assumes all subscripts will be positive, so don't say 
X(0). If a subscript is zero or negative or larger than the 
DIMENSION statement says, the computer might not notice your 
error, and will print wrong answers without warning you.
  If your program begins like this ___ 
      DIMENSION A(6)
      READ 10, A
the computer will begin by reading 6 real numbers, which will 
become A(1), A(2), A(3), A(4), A(5), and A(6).
  Double subscripts If you want T to be a table of numbers, and 
you want T to have 4 rows and 2 columns, begin your program by 
saying:
      DIMENSION T(4,2)
To print T, say:
      PRINT 10, T(1,1), T(1,2)
      PRINT 10, T(2,1), T(2,2)
      PRINT 10, T(3,1), T(3,2)
      PRINT 10, T(4,1), T(4,2)
10    FORMAT (1X,2G14.6)
If you say ___ 
      PRINT 10, T
the computer will print the entire table T, but in an undesirable 
order: it will print T(1,1), T(2,1), T(3,1), and T(4,1), then 
T(1,2), T(2,2), T(3,2), and T(4,2). Similarly, ``READ 5, T'' 
makes the computer read T in an undesirable order.

                   Implied DO
  This statement ___ 
      PRINT 10, X(3),X(4),X(5),X(6),X(7)
can be written more briefly, like this:
      PRINT 10, (X(I), I=3,7)
It means: using line 10's format, print the value of X(I), for I 
= 3 to 7. The construction (X(I), I=3,7) is called an implied DO 
loop. Notice the parenthesis at the beginning, the parenthesis at 
the end, and the commas.
  Here are other examples of implied DO loops:
Implied DO loopMeaning
(X(I), I=100,120,5)X(100),X(105),X(110),X(115),X(120)
(X(I),Y(I), I=3,7)X(3),Y(3), X(4),Y(4), X(5),Y(5), X(6),Y(6), 
X(7),Y(7)
  Calendar Here's a calendar:
 1  2  3  4  5  6  7
 8  9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31
  This program prints it:
      PRINT 10, (I, I=1,31)
10    FORMAT (1X,I2,1X,I2,1X,I2,1X,I2,1X,I2,1X,I2,1X,I2)
      END
  The program's top statement says to print every value of I, for 
I = 1 to 31. The FORMAT says to print 7 integers on each line, 
and separate the integers by spaces.
  Since 1X followed by I2 is about the same as I3, you can write 
the FORMAT more briefly:
10    FORMAT (I3,I3,I3,I3,I3,I3,I3)
You can be even briefer:
10    FORMAT (7I3)
  Tables If T is a table having 3 rows and 5 columns, these lines 
will print it in the correct order:
      PRINT 20, T(1,1), T(1,2), T(1,3), T(1,4), T(1,5)
      PRINT 20, T(2,1), T(2,2), T(2,3), T(2,4), T(2,5)
      PRINT 20, T(3,1), T(3,2), T(3,3), T(3,4), T(3,5)
20    FORMAT (1X,5G14.6)
This short cut does the same thing:
      PRINT 20, (T(1,J), J=1,5)
      PRINT 20, (T(2,J), J=1,5)
      PRINT 20, (T(3,J), J=1,5)
20    FORMAT (1X,5G14.6)
Here's a shorter cut:
      PRINT 20, ((T(I,J), J=1,5), I=1,3)
20    FORMAT (1X,5G14.6)
To read the table, say:
      READ 10, ((T(I,J), J=1,5), I=1,3)


                      DATA
  This program shows FORTRAN's DATA statement, which differs from 
BASIC's:
Program               Meaning
      DATA X/8.7/, Y/1.4/, Z/9.0/X is 8.7, Y is 1.4, and Z is 
9.0.
      X=100.6         X changes to 100.6
      PRINT 10, X,Y,Z The computer will print:
10    FORMAT (1X,3G14.6)   100.600       1.40000       9.00000
      END
  In that DATA statement, you must write 9.0, not 9: the number 
must be real, since Z is real.
  The DATA statement resembles these three statements ___ 
      X=8.7
      Y=1.4
      Z=9.0
but is faster.
  Here's another way to type the DATA statement:
      DATA X,Y,Z/8.7,1.4,9.0/
It says X, Y, and Z are 8.7, 1.4, and 9.0 respectively.
  Like the DIMENSION statement, the DATA statement belongs at the 
very top of the program. If you want both a DIMENSION statement 
and a DATA statement, put the DIMENSION statement first.
  This DATA statement says A, B, C, D, and E are all 1.7, and X, 
Y, and Z are all 9.6:
      DATA A,B,C,D,E,X,Y,Z/1.7,1.7,1.7,1.7,1.7,9.6,9.6,9.6/
Since the first 5 numbers are 1.7, and the next 3 numbers are 
9.6, you can write more briefly:
      DATA A,B,C,D,E,X,Y,Z/5*1.7,3*9.6/
  Subscripted DATA To make A be this list ___ 
81.7
92.6
25.3
49.8
72.1
68.8
begin your program with these lines:
      DIMENSION A(6)
      DATA A/81.7,92.6,25.3,49.8,72.1,68.8/
  To make T be this table ___ 
8.4 9.7
5.1 6.8
2.5 7.2
6.3 9.8
begin your program with these lines:
      DIMENSION T(4,2)
      DATA T/8.4,5.1,2.5,6.3,9.7,6.8,7.2,9.8/
Notice you must list the entire first column, then the second.

          String variables
  This program works on most computers:
      N='UP'
      PRINT 10, N
10    FORMAT (1X,A2)
      END
The top line says N is the string `UP'. The next line says to 
print N, using the format in line 10. The A2 format means a 
2-character string. (The A is derived from the word Alphabet.) 
The computer will print:
UP
  Different versions Some computers allow apostrophes only in 
FORMAT, DATA, and CALL statements. (You'll learn about CALL 
statements later.) On such computers, the statement N=`UP' is 
illegal. Instead say:
      DATA N/'UP'/
  Restrictions A string statement should look like an integer: it 
should begin with the letter I, J, K, L, M, or N. You can say 
N=`UP' but shouldn't say X=`UP'.
  The string a variable stands for must be short. You  can  say 
N=`UP' but not N= `SUPERCALIFRAGILISTICEXPIALIDOCIOUS'. The 
longest permissible string depends on your computer:
Computer            Longest string allowed
PDP-11 (using FORTRAN IV) 2 characters
PDP-11 (using FORTRAN IV-PLUS), IBM 4 characters
PDP-10, PDP-20, Honeywell 5 characters
CDC                   10 characters
  Fancy examples Examine this program:
      PRINT 10
10    FORMAT (1X,'DO YOU LIKE ME?')
      READ 20, IREPLY
20    FORMAT (A1)
      IF (IREPLY .EQ. 'Y') PRINT 30
30    FORMAT (1X,'I LIKE YOU TOO!')
      PRINT 40
40    FORMAT (1X,'SO LONG, BUSTER.')
      END
  The first pair of lines make the computer print DO YOU LIKE ME? 
The next pair set IREPLY equal to the first letter the human 
types. If the human types YESIREE, the computer will set IREPLY 
equal to `Y' and will therefore print:
I LIKE YOU TOO!
SO LONG, BUSTER.
But if the human types NOT AT ALL, the computer will set IREPLY 
equal to `N' and will therefore print just:
SO LONG, BUSTER.
In that program, the string is called IREPLY instead of REPLY, to 
make it an integer.
                                         Advanced example:
      DIMENSION NAME(25)
      PRINT 10
10    FORMAT (1X,'WHAT IS YOUR NAME?')
      READ 20, NAME
20    FORMAT (25A2)
      PRINT 30, NAME
30    FORMAT (1X,'I HATE ANYONE NAMED ',25A2)
      END
The top line says NAME will be a list of 25 elements. The next 
pair of lines print WHAT IS YOUR NAME? If the human answers ___ 
BARTHOLOMEW HIERONYMOUS MCGILLICUDDY, M.D.
the format in line 20 sets NAME equal to 25 two-character 
strings:
NAME(1) is `BA'                                  NAME(10) is 
`YM'NAME(19) is `, '
NAME(2) is `RT'                                  NAME(11) is 
`OU'NAME(20) is `M.'
NAME(3) is `HO'                                  NAME(12) is `S 
'NAME(21) is `D.'
NAME(4) is `LO'                                  NAME(13) is 
`MC'NAME(22) is `  '
NAME(5) is `ME'                                  NAME(14) is 
`GI'NAME(23) is `  '
NAME(6) is `W '                                  NAME(15) is 
`LL'NAME(24) is `  '
NAME(7) is `HI'                                  NAME(16) is 
`IC'NAME(25) is `  '
NAME(8) is `ER'                                  NAME(17) is `UD'
NAME(9) is `ON'                                  NAME(18) is `DY'
Format 30 prints:
I HATE ANYONE NAMED BARTHOLOMEW HIERONYMOUS MCGILLICUDDY, M.D.
                                         To make that program run 
faster, use fewer strings. For example, if you have a CDC 
computer, each string can be as long as 10 characters, so you 
need only 5 strings to make 50 characters:
      DIMENSION NAME(5)
      PRINT 10
10    FORMAT (1X,'WHAT IS YOUR NAME?')
      READ 20, NAME
20    FORMAT (5A10)
      PRINT 30, NAME
30    FORMAT (1X,'I HATE ANYONE NAMED ',5A10)
      END
                                         FORTRAN 77 strings On 
computer having FORTRAN 77, and on IBM computers using WATFIV, 
you can request super-long strings:
      CHARACTER*50 NAME
      PRINT 10
10    FORMAT (1X,'WHAT IS YOUR NAME?')
      READ 20, NAME
20    FORMAT (A50)
      PRINT 30, NAME
30    FORMAT (1X,'I HATE ANYONE NAMED ',A50)
      END
                                         The top line requests 
that NAME be a 50-character string. Like the DIMENSION statement, 
the CHARACTER statement must be put at the very top of the 
program, above even the DATA statements.

              FUNCTIONS
  To do advanced math, use FORTRAN's functions.

             Square root
  This program finds the square root of 9:
      A=SQRT(9.0)
      PRINT 10, A
10    FORMAT (1X,G14.6)
      END
The computer will print:
   3.00000
  In that program, you must say SQRT(9.0), not SQRT(9). If you 
say SQRT(9), the computer will either gripe or print a wrong 
answer.
  The number in parentheses must be real. That's why you can say 
SQRT(9.0) but not SQRT(9). You can say SQRT(8.0+1.0) but not 
SQRT(8+1). You can say SQRT(X) but not SQRT(J).
  Be careful when you translate from BASIC to FORTRAN: in BASIC, 
you say SQR; in FORTRAN, you say SQRT instead.
  This program prints a table, showing the square root of 2.0, 
the square root of 3.0, the square root of 4.0, the square root 
of 5.0, etc.:
      X=2.0
10    Y=SQRT(X)
      PRINT 20, X,Y
20    FORMAT (1X,2G14.6)
      X=X+1.0
      GO TO 10
      END
The computer will print:
   2.00000       1.41421
   3.00000       1.73205
   4.00000       2.00000
   5.00000       2.23607
   6.00000       2.44949
   7.00000       2.64575
   8.00000       2.82843
   9.00000       3.00000
   10.0000       3.16228
   etc.

                FLOAT
  If you say FLOAT, the computer will create a FLOATing-point 
number (in other words, a real number), by using an integer. For 
example, FLOAT(3) is 3.0. If J is 7, then FLOAT(J) is 7.0.
  The word FLOAT can help you solve the following problems. . . . 
  Find the square root of an integer J Unfortunately, you aren't 
allowed to say SQRT(J), because what you take the square root of 
must be a real number. You can say SQRT(X) but not SQRT(J). 
Solution: say X=J, and then say SQRT(X). Shorter solution: say 
SQRT(FLOAT(J)).
  Divide J by K accurately Unfortunately, saying J/K gives an 
inaccurate answer, because when the computer divides integers it 
gives an integer answer, instead of an accurate real answer. 
Solution: say X=J, then Y=K, then X/Y. Shorter solution: say 
FLOAT(J)/FLOAT(K).
                                                  Random numbers
                                         Here's how to set R 
equal to a random decimal between 0 and 1:
Computer                                         What to say
CDC                                              R=RANF(0)
PDP-10, PDP-11                                   R=RAN(0)
PDP-11                                           
R=RAN(ISEED,ISEED2)
                                         To randomize the random 
numbers on PDP-10 and PDP-20 computers, put these lines near the 
top of your program:
      CALL TIME(ISEED,ISEED2)
      CALL SETRAN(MOD(ISEED/2+ISEED2/2, 2147483648))
On other computers, randomizing is even more complicated; ask the 
people who run your computer center.

                                                 Maxima and minima
                                         To find the maximum real 
number in a list, ask for AMAX1.
                                         For example, AMAX1(4.7, 
2.8, 41.6, 9.2, 82.3, 9.7) is 82.3. And AMIN1(4.7, 2.8, 41.6, 
9.2, 82.3, 9.7) is the minimum, which is 2.8.
                                         If the numbers in the 
list are integers, say MAX0 instead of AMAX1, and say MIN0 
instead of AMIN1. When you type ``MAX0'' and ``MIN0'', make sure 
you end with a zero, not the letter ``oh''.

                                                  Absolute value
                                         ABS(X) means the 
ABSolute value of X; in other words, X without its minus sign. 
For example:
ABS(-5.2) is 5.2
ABS(-7.0) is 7.0
ABS(9.3)  is 9.3
                                         For integers, say IABS 
instead of ABS. For example, IABS(-7) is 7.

                                                     Remainder
                                         When you divide 11 by 4, 
the remainder is 3:
     2
4 ) 11
    -8
     3 is the remainder
                                         If you ask for MOD(11,4) 
the computer will divide 11 by 4 and get the remainder, which is 
3; so MOD(11,4) is 3.
                                         Use MOD for integers; 
use AMOD for reals. For example, AMOD(11.0, 4.0) is 3.0.
                  Trigonometry
  If your computer has FORTRAN 77, or your computer is an IBM 
having FORTRAN H-EXTENDED, or your computer is a PDP-11 having 
FORTRAN IV-PLUS, you can use these trigonometric functions:
SymbolMeaning
SIN(X)the SINe of X radians
COS(X)the COSine of X radians
TAN(X)the TANgent of X radians

ASIN(X)the ArcSINe of X in radians; the number whose sine is X
ACOS(X)the ArcCOSine of X in radians; the number whose cosine is 
X
ATAN(X)the ArcTANgent of X in radians; the number whose tangent 
is X

SINH(X)the SINe Hyperbolic of X
COSH(X)the COSine Hyperbolic of X
TANH(X)the TANgent Hyperbolic of X
  If your computer is old-fashioned, it restricts you:
Old-fashioned systemRestriction
PDP-10, PDP-20  you can't say TAN(X)
CDC             you can't say SINH(X) or COSH(X)
other IBM computerssay ARSIN(X), not ASIN(X); say ARCOS(X), not 
ACOS(X)
FORTRAN IV computersyou can't say TAN(X), ASIN(X), ACOS(X), 
SINH(X), COSH(X)
  You can replace X by any real number. For example, you can say 
SIN(4.0) but not SIN(4); you can say SIN(Y) but not SIN(J).
  Be careful when you translate from BASIC to FORTRAN: in BASIC, 
you say ATN; in FORTRAN, you say ATAN instead.
  You've seen that SIN(X) is the sine of X radians. But what's 
the sine of X degrees? On PDP-10 and PDP-20 computers, you can 
find the sine of X degrees by asking for SIND(X); and you can 
find the cosine of X degrees by asking for COSD(X).
  ATAN2(Y,X) is about the same as ATAN(Y/X), but is faster, more 
accurate, and gives a useful answer even when X is zero or 
negative. ATAN2(Y,X) is the angle (in radians) of the line that 
goes through the origin and the point (X,Y).

                    Calculus
  You can use these functions:
FunctionMeaning

EXP(X)  eX

ALOG(X) loge X

ALOG10(X)log10 X
  You can replace X by any real number, but not by an integer. 
Each of those functions produces a real answer, since none of 
them begins with I, J, K, L, M, or N.
  The logarithm function is called ALOG instead of LOG, to avoid 
beginning with L. Be careful when you translate from BASIC to 
FORTRAN: in BASIC, you say LOG; in FORTRAN, you say ALOG instead.


                 EXOTIC FEATURES
  Let's take off our handcuffs and go wild!
  Let's go beyond integers and reals, to other kinds of numbers 
that are wilder: double precision and complex.
  Let's go beyond standard functions and invent our own 
functions. Let's go beyond standard statements and invent our own 
statements, by using subroutines and comments. Let's go beyond 
the DATA statement and invent data files.
  Here we go. . . . 

                    Comments
  If you type C instead of a line number, the computer will 
ignore the line.
      N=50+13
C  I HATE COMPUTERS!
      PRINT 10, N
10    FORMAT (1X,I14)
      END
The computer will ignore the Comment. The computer will print 63.
  The C in FORTRAN is like the REMARK in BASIC: use it to 
document your program. 

                DOUBLE PRECISION
  Some computers are more accurate than others:
Computer      Accuracy for real numbers
PDP-11, IBM    7 digits
PDP-10, PDP-20, Honeywell 8 digits
CDC           14 digits
  For example, suppose you feed this program to a PDP-11 or IBM:
      A=5398.1642376236
      PRINT 10, A
10    FORMAT (1X,F15.10)
      END
Expect the first 7 digits the computer prints to be correct 
(5398.164), but the remaining digits it prints to be wrong: they 
arise from round-off error inside the computer.
  A PDP-11 or IBM prints some numbers to an accuracy of 8 digits 
and others to an accuracy of just 6 digits, but 7 digits is 
typical.
  For real numbers, I recommend you use a G14.6 format, because 
it's safe: it prints just the first 6 digits. If you want to see 
further digits that are probably correct, use these formats 
instead:
Computer      FormatWhat the format does
PDP-11, IBM   G15.7 prints the first  7 digits
PDP-10, PDP-20, HoneywellG16.8prints the first  8 digits
CDC           G22.14prints the first 14 digits
  You can obtain extra accuracy, by requesting double precision:
Computer          Accuracy for double precisionFormat
PDP-11            14 digits             D22.14
PDP-10 (using KA), Honeywell16 digits   D24.16
IBM               17 digits             D25.17
PDP-10 (using KI or KL), PDP-2018 digitsD26.18
CDC               29 digits             D37.29
  Each of these programs computes the square root of 6.3x108 on a 
PDP-11 computer:
Using reals     Using double precision
                      DOUBLE PRECISION A
      A=SQRT(6.3E8)      A=DSQRT(6.3D8)
      PRINT 10, A      PRINT 10, A
10    FORMAT (1X,G15.7)10    FORMAT (1X,D22.14)
      END             END
The program on the left computes 7 digits. The program on the 
right computes 14. Comparing the programs, you'll notice four 
differences:
                                                     1. For 
double precision you must use double precision numbers. Instead 
of saying 6.3E8, say 6.3D8. The D means Double precision.
Real number                                                  
Double precision
6.3E8                                                        
6.3D8
29.6                                                         
29.6D0
                                                                  
                                                                  
this is a zero
                                                     2. For 
double precision, you must use double precision functions. 
Instead of saying SQRT, say DSQRT.
Real function                                                
Double precision
SQRT                                                         
DSQRT

AMAX1                                                        
DMAX1
AMIN1                                                        
DMIN1

ABS                                                          DABS
AMOD                                                         DMOD
EXP                                                          DEXP

ALOG                                                         DLOG
ALOG10                                                       
DLOG10

SIN                                                          DSIN
COS                                                          DCOS
TAN                                                          DTAN

ASIN                                                         
DASIN
ACOS                                                         
DACOS
ATAN                                                         
DATAN
ATAN2                                                        
DATAN2

SINH                                                         
DSINH
COSH                                                         
DCOSH
TANH                                                         
DTANH
                                                     3. For 
double precision, you must use double precision variables. 
Normally, the variable A would be real; to make it double 
precision instead, say:
      DOUBLE PRECISION A
Normally, the variables LENGTH and MASS would be integers, and 
SPEED would be real; to make them all double precision, say:
      DOUBLE PRECISION LENGTH,MASS,SPEED
Like the DIMENSION and CHARACTER statements, the DOUBLE PRECISION 
statement must be put at the very top of the program, above even 
the DATA statements. If you say ___ 
      IMPLICIT DOUBLE PRECISION(D)
every variable whose first letter is D will automatically be 
double precision; for example, DISTAN and DIAMET and DSIZE will 
automatically be double precision.
                                                     4. For 
double precision you must use double precision formats. Instead 
of a G format, use D22.14, or whichever D format is appropriate 
for your computer.
                                                     Expense 
Although double precision arithmetic is more precise than real 
arithmetic, it's also more expensive: it consumes more of the 
computer's time, and the numbers consume more of the computer's 
memory.
  Combinations If you combine an integer or a real number with a 
double precision number, the answer will be double precision.

               COMPLEX
  In mathematics, the square root of -1 is called i. So i2 is -1. 
The number i obeys most of the rules of algebra:
 i+i  is 2i
2i+3i is 5i
(8+2i) + (7+3i) is 15+5i
(8+2i) * (7+3i) is 8*7 + 8*3i + 2i*7 + 2i*3i,
          which is 56 + 24i + 14i + 6i2,
          which is 56 + 24i + 14i + -6,
          which is 50 + 38i
  The number i is neither positive nor negative nor zero; it's 
pictured instead as being above the real number line:
                i
-5 -4 -3 -2 -1  0  1  2  3  4  5
2i is further above the real number line: it's 2 units above 0. 
Another example: 5+2i is 2 units above 5.
  A number that involves i is called complex. So 5+2i is complex. 
Its real part is 5, its imaginary part is 2, and its conjugate is 
5-2i.
  This program multiplies 8+2i by 7+3i and prints the correct 
answer, 50+38i:
      COMPLEX B
      B=(8.0, 2.0) * (7.0, 3.0)
      PRINT 10, B
10    FORMAT (1X,2G14.6)
      END
  FORTRAN says (8.0, 2.0) instead of 8+2i. The decimal points and 
parentheses are required.
  To make B complex instead of real, say COMPLEX B. Like the 
DIMENSION and CHARACTER and DOUBLE PRECISION statements, the 
COMPLEX statement must be put at the very top of the program, 
above even the DATA statements.
  To print B, use the G14.6 format twice (once for the real part, 
and once for the imaginary part). The computer will print:
   50.0000       38.0000
  If you say IMPLICIT COMPLEX(C), every variable whose first 
letter is C will automatically be complex.
  Although you can write 8+2i as (8.0, 2.0), you cannot write 
X+Yi as (X, Y); instead write CMPLX(X, Y).
  Here's the rule: to build a complex number from variables 
instead of from constants, say CMPLX. The variables that the 
complex number is built from must be real.
  If B is complex, you can use these functions:
FunctionMeaning
CSQRT(B)the complex number that's the square root of B

CSIN(B) the complex number that's the sine of B
CCOS(B) the complex number that's the cosine of B

CEXP(B) the complex number that's eB
CLOG(B) the complex number that's log B

CABS(B) the real number that's the absolute value of B
REAL(B) the real number that's the real part of B
AIMAG(B)the real number that's the imaginary part of B

CONJG(B)the complex number that's the conjugate of B

                                         This program finds the 
square root of -9 and prints the correct answer, 3i:
      COMPLEX B,Z
      B=-9
      Z=CSQRT(B)
      PRINT 10, Z
10    FORMAT (1X,2G14.6)
      END
Since the top line says B is complex, the second line makes B the 
complex number -9+0i. The next line makes Z the square root of 
-9+0i, which is 0+3i. The computer will print the 0 and the 3:
   0.000000       3.00000
                                         Since that program sets 
B equal to -9+0i, which FORTRAN writes as (-9.0, 0.0), you can 
shorten the program to this:
      COMPLEX Z
      Z=CSQRT( (-9.0, 0.0) )
      PRINT 10, Z
10    FORMAT (1X,2G14.6)
      END
Make sure the number inside CSQRT's parentheses is complex: you 
need the decimal points, comma, and parentheses.
                                         When the computer 
combines a complex number with an integer, a real, or a double 
precision number, the result is complex.
                                         Some computers limit 
your use of complex numbers, by restrictions such as:
``Don't say a complex number equals a double precision number.''
``Don't combine a complex number with a double precision 
number.''
``Don't raise a number to a complex power.''
``Don't raise a complex number to a power, unless the power is an 
integer.''
Find out whether your computer has those restrictions.
             Subroutines
  This program is a combination of two routines:
      PRINT 10
10    FORMAT (1X,'KIDS')
      CALL YUMMY
      PRINT 20
20    FORMAT (1X,'LOLLIPOPS')
      END

      SUBROUTINE YUMMY
      PRINT 10
10    FORMAT (1X,'SUCK')
      RETURN
      END
  Each routine ends with the word END.
  The first routine is called the main routine.
  The second routine is called the subroutine, and begins with 
the word SUBROUTINE. I decided to name it YUMMY, so its top line 
says SUBROUTINE YUMMY.
  Above the word SUBROUTINE, I put a blank line. That blank line 
is optional; it helps humans find where the subroutine begins.
  In the main routine, the top pair of lines makes the computer 
print:
KIDS
The next line says CALL YUMMY, which makes the computer skip down 
to subroutine YUMMY. Subroutine YUMMY makes the computer print 
___ 
SUCK
and then RETURN to the main routine, which finishes by printing:
LOLLIPOPS
  Altogether, the program prints:
KIDS
SUCK
LOLLIPOPS
  Notice that line 10 in the main routine is different from line 
10 in the subroutine. Similarly, an X in the main routine is 
different from one in the subroutine:
      X=3.4
      CALL FUNNY
      PRINT 10,X
10    FORMAT (1X,G14.6)
      END

      SUBROUTINE FUNNY
      X=925.1
      Y=X+1.0
      PRINT 10, Y
10    FORMAT (1X,G14.6)
      RETURN
      END
The computer will set the main routine's X equal to 3.4. Then it 
will call FUNNY. The X in FUNNY is 925.1, so Y is 926.1, and the 
computer will print:
   926.100
When the computer returns to the main routine, it will print the 
main routine's X, which is still:
   3.40000

                                         Passing information 
between routines To pass information from one routine to another, 
put the information in parentheses:
      A=5.2
      CALL LEMON(A)
      PRINT 10, A
10    FORMAT (1X,G14.6)
      END

      SUBROUTINE LEMON(X)
      PRINT 100, X
100   FORMAT (1X,G14.6)
      X=7.1
      RETURN
      END
The computer sets A equal to 5.2. Then it calls LEMON. The A and 
X in parentheses mean: the main routine's A is the subroutine's 
X, so the subroutine's X is 5.2. Line 100 prints:
   5.20000
The next line changes X to 7.1. When the computer returns to the 
main routine, the main routine's A is the subroutine's X, so the 
main routine's A is 7.1. Line 10 prints:
   7.10000
                                         A harder example:
      P=2.1
      CALL JUNK(P)
      PRINT 10, P
10    FORMAT (1X,G14.6)
      END

      SUBROUTINE JUNK(P)
      P=3.0*P
      RETURN
      END
The computer sets P equal to 2.1 and then calls JUNK. The P in 
parentheses means: the main routine's P is the subroutine's P. 
The subroutine triples P, so P becomes 6.3. When the computer 
returns to the main routine, line 10 prints:
   6.30000
                                         Another example:
      Q=1.4
      CALL FAT(5.0, Q+.3, R)
      PRINT 10, R
10    FORMAT (1X,G14.6)
      END

      SUBROUTINE FAT(X, Y, Z)
      Z=X+Y
      RETURN
      END
When the main routine calls FAT, the subroutine's X is 5.0; Y is 
Q+.3, which is 1.7; and Z is R, which is undefined. The 
subroutine sets Z equal to X+Y, which is 6.7. When the computer 
returns to the main routine, the main routine's R is the 
subroutine's Z, which is 6.7. Line 10 prints:
   6.70000
                                         In that CALL, you must 
say 5.0, not 5, since X must be real. Saying 5 will confuse the 
computer and make it print a wrong answer.
  Sum & average of a trio This subroutine finds the sum and 
average of three real numbers ___ X, Y, and Z:
      SUBROUTINE STAT(X, Y, Z, SUM, AVERAG)
      SUM=X+Y+Z
      AVERAG=SUM/3.0
      RETURN
      END
  This main routine uses STAT to find the sum and average of 8.1, 
2.6, and 9.3:
      CALL STAT(8.1, 2.6, 9.3, SUM, AVERAG)
      PRINT 10, SUM,AVERAG
10    FORMAT (1X,2G14.6)
      END
  This subroutine finds the sum and average of three double 
precision numbers:
      SUBROUTINE DSTAT(X, Y, Z, SUM, AVERAG)
      DOUBLE PRECISION X, Y, Z, SUM, AVERAG
      SUM=X+Y+Z
      AVERAG=SUM/3D0
      RETURN
      END
This main routine uses DSTAT to find the sum and average of ã, e, 
and my phone number (6662666):
      DOUBLE PRECISION SUM, AVERAG
      CALL DSTAT(3.1415926535898D0, 2.7182818284590D0, 6662666D0, 
SUM,
     6AVERAG)
      PRINT 10, SUM, AVERAG
10    FORMAT (1X,2D22.14)
      END
You must say DOUBLE PRECISION in both the main routine and the 
subroutine.
  Sum & average of a long list This subroutine finds the sum and 
average of X1, X2, X3, . . . , XN:
      SUBROUTINE STAT2(X, N, SUM, AVERAG)
      DIMENSION X(N)
      SUM=0.0
      DO 10 I=1,N
         SUM=SUM+X(I)
10    CONTINUE
      AVERAG=SUM/N
      RETURN
      END
  This main routine uses STAT2 to find the sum and average of 
8.4, 9.6, 20.1, 7.2, 91.5, and 3.6:
      DIMENSION X(6)
      DATA X/8.4,9.6,20.1,7.2,91.5,3.6/
      CALL STAT2(X, 6, SUM, AVERAG)
      PRINT 10, SUM,AVERAG
10    FORMAT (1X,2G14.6)
      END
  You must put the DIMENSION statement in both the main routine 
and the subroutine. In the main routine, the DIMENSION must be a 
constant (6); in the subroutine, the DIMENSION can be a variable 
(N).
  This main routine asks you to input some numbers, then prints 
their sum and average by using STAT2:
      DIMENSION X(100)
      PRINT 10
10    FORMAT (1X,'HOW MANY NUMBERS WOULD YOU LIKE TO GIVE ME?')
      READ *, N
      PRINT 20
20    FORMAT (1X,'TYPE THE NUMBERS')
      READ *, (X(I), I=1,N)
      CALL STAT(X, N, SUM, AVERAG)
      PRINT 10, SUM,AVERAG
10    FORMAT (1X,'THE SUM IS',G14.6,' AND THE AVERAGE IS',G14.6)
      END
That DIMENSION statement lets you input up to 100 numbers.
                                                     If a main 
routine says DIMENSION X(100), and X is passed between the main 
routine and the subroutine, the subroutine's DIMENSION statement 
must say no more than X(100): if the subroutine's DIMENSION 
statement says X(N), the N must be no more than 100.
                                                     Passing 
double subscripts For double subscripts, the main routine's 
DIMENSION statement must be exactly the same as the subroutine's.
                                                     For example, 
suppose the main routine says DIMENSION X(25,4). Then the 
subroutine must say DIMENSION X(25,4) also. The subroutine must 
not say DIMENSION X(20,3). If the subroutine says DIMENSION 
X(M,N), the M must be exactly 25.
                                                     Famous 
subroutines The Scientific Subroutine Package (SSP) is a 
collection of subroutines written by IBM that do statistics, 
calculus, equation-solving, and advanced math. The Calcomp 
subroutines make the computer operate a Calcomp plotter (a device 
that draws fancy shapes on paper, by using a felt-tip or 
ballpoint pen).
                                                     Most large 
computers store the SSP and Calcomp subroutines on disk 
permanently. Ask the people in your computer center how to 
combine your own main routines with those subroutines, and how to 
put your own library of subroutines onto the disk.
                                                     How to write 
a big program If you and your friends want to write a big program 
together, divide the problem into a main routine and several 
subroutines, and have each person write one routine.
                                                     Although 
you'll need a group conference to decide what the SUBROUTINE and 
CALL statements will be, you don't have to agree on the names of 
variables, since the names of subroutine variables have nothing 
to do with the names of main-routine variables.
         Your own functions
  Instead of using functions such as SQRT and ABS, you can invent 
your own functions. Here's how to invent a function called F, and 
how to use the function you've invented:
      A=F(5.2)+1.0
      PRINT 10, A
10    FORMAT (1X,G14.6)
      END

      FUNCTION F(X)
      F=2.0*X
      RETURN
      END
  The program consists of two routines. The first routine is the 
main routine. The second routine is the definition of the 
FUNCTION F. Each routine ends with the word END.
  The main routine's top line requires the computer to find 
F(5.2), so the computer hunts for the definition of FUNCTION F. 
The definition says F is twice 5.2, which is 10.4. So A is 11.4. 
The computer will print:
   11.40000
  Like a subroutine, a function definition can be very long and 
have many variables in parentheses.
  Naming your function You can give your function the name F or G 
or any other name, such as MASS. If the function's name begins 
with I, J, K, L, M, or N, the computer will assume its value is 
an integer.
  If you want the function MASS(X) to be double precision instead 
of an integer, begin your main routine by saying ___ 
      DOUBLE PRECISION MASS
and begin your function definition with this line:
      DOUBLE PRECISION FUNCTION MASS(X)

                                                       Files
                                         The computer can write 
its answers onto a data file:
      A=14.6+75.2
      WRITE(3,10) A
10    FORMAT (1X,G14.6)
      WRITE(7,20)
20    FORMAT (1X,'TINA, PLEASE TICKLE MY TUBA')
      END
Since A is 89.8, the second line makes the computer write 89.8 
onto ``file 3'', using line 10's format. The next pair of lines 
make the computer write onto ``file 7'', using line 20's format; 
so the computer will write TINA, PLEASE TICKLE MY TUBA onto file 
7.
                                         Before running that 
program, tell the computer where to put files 3 and 7. You can 
make the computer put them on a disk, line printer, tape, 
terminal, or wherever else you please. Ask the people in your 
computer center how to tell the computer where to put the files.
                                         If your program has many 
statements saying to write onto file 3, the computer will write 
many lines onto file 3, so the file will become long.
                                         Use carriage controls 
only if the file is on a line printer or terminal.
                                         If you say ___ 
      READ(4,30) X
the computer will read the value of X from file 4, using line 
30's format. If you say file 4 is the card reader, the computer 
will wait for you to feed in a card; it you say file 4 is your 
terminal, the computer will wait for you to type on the terminal; 
if you say file 4 is on a tape or disk, the computer will assume 
you created the file before running the program.
                                         For handling files, the 
word READ works even on PDP computers.
                                         For PDP-10 and PDP-20 
computers, here's how to make file 3 be on disk and named JOE. . 
. . Near the beginning of your program, say:
      OPEN(UNIT=3, DEVICE='DSK', FILE='JOE.')
Near the end of your program, say:
      CLOSE(UNIT=3)